home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 August: Technology Seed / August 1998 ADC Seed CD.toast / Mac OS 8.5b2 / allegro-b2-pseudo-SDK / PInterfaces / ATSUnicode.p < prev    next >
Encoding:
Text File  |  1998-07-17  |  28.6 KB  |  492 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        ATSUnicode.p
  3.  
  4.      Contains:    Public interfaces for Apple Type Services for Unicode Imaging
  5.  
  6.      Version:    Technology:    Allegro
  7.                  Release:    Allego Seed, Use with 3.1 Universal Interfaces
  8.  
  9.      Copyright:    © 1997-1998 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT ATSUnicode;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __ATSUNICODE__}
  28. {$SETC __ATSUNICODE__ := 1}
  29.  
  30. {$I+}
  31. {$SETC ATSUnicodeIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __ATSLAYOUTTYPES__}
  35. {$I ATSLayoutTypes.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __SFNTLAYOUTTYPES__}
  38. {$I SFNTLayoutTypes.p}
  39. {$ENDC}
  40.  
  41. {$IFC UNDEFINED __MACTYPES__}
  42. {$I MacTypes.p}
  43. {$ENDC}
  44. {$IFC UNDEFINED __QUICKDRAW__}
  45. {$I Quickdraw.p}
  46. {$ENDC}
  47. {$IFC UNDEFINED __TEXTCOMMON__}
  48. {$I TextCommon.p}
  49. {$ENDC}
  50.  
  51.  
  52. {$PUSH}
  53. {$ALIGN MAC68K}
  54. {$LibExport+}
  55.  
  56. {**********}
  57. {    Types    }
  58. {**********}
  59.  
  60. TYPE
  61.     UniCharArrayHandle                    = ^UniCharArrayPtr;
  62. {
  63.       UniCharArrayHandle is a handle type to correspond to 
  64.       UniCharArrayPtr, defined in Unicode.h.  It refers 
  65.       to a handle, interpreted as a pointer to an array 
  66.       of UniChar's (UInt16's).
  67. }
  68.     UniCharArrayOffset                    = UInt32;
  69. {
  70.       UniCharArrayOffset is used to indicate an offset 
  71.       into an array of UniChar's (UInt16's).  
  72. }
  73.     ATSUTextMeasurement                    = Fixed;
  74. {
  75.       ATSUTextMeasurement is exactly what its name implies:  
  76.       a measurement of the size in some direction of text:  
  77.       height, width, ascent, descent, and so on.  
  78. }
  79.     ATSUFontID                            = UInt32;
  80. {
  81.       ATSUFontID indicates a particular font family and face.  
  82.       ATSUFontID's are not guaranteed to remain constant across 
  83.       reboots.  Clients should use the font's unique name to 
  84.       get a font token to store in documents which is 
  85.       guaranteed to remain constant across reboots. 
  86. }
  87.     ATSUFontFeatureType                    = UInt16;
  88.     ATSUFontFeatureSelector                = UInt16;
  89. {
  90.       ATSUFontFeatureType and ATSUFontFeatureSelector are used 
  91.       to identify font features.  
  92. }
  93.     ATSUFontVariationAxis                = FourCharCode;
  94.     ATSUFontVariationValue                = Fixed;
  95. {
  96.       ATSUFontVariationAxis and ATSUFontVariationValue are used 
  97.       in connection with font variations.  
  98. }
  99.     ATSUTextLayout = ^LONGINT;
  100. {
  101.       ATSUTextLayout is used to store the attribute information 
  102.       associated with a contiguous block of UniChar's (UInt16's) 
  103.       in memory.  It's typed to be an opaque structure.  
  104. }
  105.     ATSUStyle = ^LONGINT;
  106. {
  107.       ATSUStyle is used to store a set of individual attributes, 
  108.       font features, and font variations.  It's typed to be 
  109.       an opaque structure.  
  110. }
  111.     ATSUAttributeTag                    = UInt32;
  112. {
  113.       ATSUAttributeTag is used to indicate the particular type 
  114.       of attribute under consideration:  font, size, color, 
  115.       and so on.  
  116.       Each style run may have at most one attribute with a 
  117.       given ATSUAttributeTag (i.e., a style run can't have 
  118.       more than one font or size) but may have none.  
  119. }
  120.     ATSUAttributeValuePtr                = Ptr;
  121. {
  122.       ATSUAttributeValuePtr is used to provide generic access 
  123.       to storage of attribute values, which vary in size.
  124. }
  125.     ATSUAttributeInfoPtr = ^ATSUAttributeInfo;
  126.     ATSUAttributeInfo = RECORD
  127.         fTag:                    ATSUAttributeTag;
  128.         fValueSize:                ByteCount;
  129.     END;
  130.  
  131. {
  132.       ATSUAttributeInfo is used to provide a tag/size pairing.  
  133.       This makes it possible to provide the client information   
  134.       about all the attributes for a given range of text.  This   
  135.       structure is only used to return to the client information   
  136.       about a complete set of attributes.  An array of   
  137.       ATSUAttributeInfos is passed as a parameter so that the   
  138.       client can find out what attributes are set and what their   
  139.       individual sizes are; with that information, they can then   
  140.       query about the values of the attributes they're interested   
  141.       in.  Because arrays of ATSUAttributeInfos are used as parameters   
  142.       to functions, they have to be of a fixed size, hence the   
  143.       value is not included in the structure.  
  144. }
  145.     ATSUCaretPtr = ^ATSUCaret;
  146.     ATSUCaret = RECORD
  147.         fX:                        Fixed;
  148.         fY:                        Fixed;
  149.         fDeltaX:                Fixed;
  150.         fDeltaY:                Fixed;
  151.     END;
  152.  
  153. {
  154.       ATSUCaret is to contain complete information regarding a caret:  
  155.       its x- and y-positions (relative to the line's origin), and 
  156.       a delta-x and delta-y indicating the caret's slope.  If the 
  157.       caret is vertical, fDeltaX is 0; if it's horizontal, fDeltaY 
  158.       is 0.  
  159. }
  160.     ATSUCursorMovementType                = LONGINT;
  161. {
  162.       ATSUCursorMovementType currently can take three values 
  163.       (kATSUByCharacter, kATSUByCluster, and kATSUByWord) 
  164.       and is used to indicate how much to move the cursor.  
  165. }
  166.     ATSUVerticalCharacterType            = UInt16;
  167. {
  168.       ATSUVerticalCharacterType currently can take two values 
  169.       (kATSUStronglyVertical, and kATSUStronglyHorizontal) and 
  170.       is used to indicate whether text is to be laid out as 
  171.       vertical glyphs or horizontal glyphs.  
  172. }
  173.     ATSUStyleComparison                    = UInt16;
  174. {
  175.       ATSUStyleComparison is an enumeration with four values 
  176.       (kATUStyleUnequal, ATSUStyleContains, kATSUStyleEquals, 
  177.       and kATSUStyleContainedBy), and is used by ATSUCompareStyles() 
  178.       to indicate if the first style parameter contains as a 
  179.       proper subset, is equal to, or is contained by the second 
  180.       style parameter.
  181. }
  182. {**************************************************}
  183. {    Gestalt selectors                                }
  184. {        Move into Gestalt.i when they're stable!!!!    }
  185. {**************************************************}
  186.  
  187. CONST
  188.     gestaltATSUVersion            = 'uisv';
  189.     gestaltATSUFeatures            = 'uisf';
  190.  
  191.     gestaltOriginalATSUVersion    = $00010000;
  192.  
  193. {**************}
  194. {    Error codes    }
  195. {**************}
  196.     kATSUInvalidTextLayoutErr    = -8790;                        {     An attempt was made to use a ATSUTextLayout  }
  197.                                                                 {     which hadn't been initialized or is otherwise  }
  198.                                                                 {     in an invalid state.  }
  199.     kATSUInvalidStyleErr        = -8791;                        {     An attempt was made to use a ATSUStyle which   }
  200.                                                                 {     hadn't been properly allocated or is otherwise   }
  201.                                                                 {     in an invalid state.   }
  202.     kATSUInvalidTextRangeErr    = -8792;                        {     An attempt was made to extract information    }
  203.                                                                 {     information from or perform an operation on a    }
  204.                                                                 {     ATSUTextLayout for a range of text not covered    }
  205.                                                                 {     by the ATSUTextLayout.   }
  206.     kATSUFontsMatched            = -8793;                        {     This is not an error code but is returned by     }
  207.                                                                 {     ATSUMatchFontsToText() when changes need to     }
  208.                                                                 {     be made to the fonts associated with the text.   }
  209.     kATSUFontsNotMatched        = -8794;                        {     This value is returned by ATSUMatchFontsToText()     }
  210.                                                                 {     when the text contains Unicode characters which     }
  211.                                                                 {     cannot be represented by any installed font.   }
  212.     kATSUNoCorrespondingFontErr    = -8795;                        {     This value is retrned by font ID conversion  }
  213.                                                                 {     routines ATSUFONDtoFontID() and ATSUFontIDtoFOND()  }
  214.                                                                 {     to indicate that the input font ID is valid but  }
  215.                                                                 {     there is no conversion possible.  For example,  }
  216.                                                                 {     data-fork fonts can only be used with ATSUI not  }
  217.                                                                 {     the FontManager, and so converting an ATSUIFontID  }
  218.                                                                 {     for such a font will fail.    }
  219.     kATSUInvalidFontErr            = -8796;                        {     Used when an attempt was made to use an invalid font ID. }
  220.     kATSUInvalidAttributeValueErr = -8797;                        {     Used when an attempt was made to use an attribute with  }
  221.                                                                 {     a bad or undefined value.   }
  222.     kATSUInvalidAttributeSizeErr = -8798;                        {     Used when an attempt was made to use an attribute with a  }
  223.                                                                 {     bad size.   }
  224.     kATSUInvalidAttributeTagErr    = -8799;                        {     Used when an attempt was made to use a tag value that }
  225.                                                                 {     was not appropriate for the function call it was used.   }
  226.     kATSUInvalidCacheErr        = -8800;                        {     Used when an attempt was made to read in style data  }
  227.                                                                 {     from an invalid cache.  Either the format of the  }
  228.                                                                 {     cached data doesn't match that used by Apple Type  }
  229.                                                                 {     Services for Unicode™ Imaging, or the cached data  }
  230.                                                                 {     is corrupt.   }
  231.     kATSUNotSetErr                = -8801;                        {     Used when the client attempts to retrieve an attribute,  }
  232.                                                                 {     font feature, or font variation from a style when it  }
  233.                                                                 {     hadn't been set.  In such a case, the default value will }
  234.                                                                 {     be returned for the attribute's value. }
  235.     kATSUNoStyleRunsAssignedErr    = -8802;                        {     Used when an attempt was made to measure, highlight or draw }
  236.                                                                 {     a ATSUTextLayout object that has no styleRuns associated with it. }
  237.                                                                 {     Used when QuickDraw Text encounters an error rendering or measuring }
  238.     kATSUQuickDrawTextErr        = -8803;                        {     a line of ATSUI text. }
  239.  
  240. {*****************************************************************************}
  241. {    ATSUI Attribute tags:  Apple reserves values 0 to 65,535 (0 to 0x0000FFFF) }
  242. {    ATSUI clients may create their own tags with any other value               }
  243. {*****************************************************************************}
  244. {    Line Control Attribute Tags }
  245.     kATSULineWidthTag            = 1;                            {     Type:            ATSUTextMeasurement }
  246.                                                                 {     Default value:    0 }
  247.     kATSULineRotationTag        = 2;                            {     Type:            Fixed (fixed value in degrees in right-handed coordinate system) }
  248.                                                                 {     Default value:    0 }
  249.     kATSULineDirectionTag        = 3;                            {     Type:            Boolean; values 0 or 1 (see below for value identities) }
  250.                                                                 {     Default value:    kATSULeftToRightBaseDirection }
  251.     kATSULineJustificationFactorTag = 4;                        {     Type:            Fract between 0 and 1 }
  252.                                                                 {     Default value:    kATSUNoJustification }
  253.     kATSULineFlushFactorTag        = 5;                            {     Type:            Fract between 0 and 1  }
  254.                                                                 {     Default value:    kATSUStartAlignment }
  255.     kATSULineBaselineValuesTag    = 6;                            {     Type:            BslnBaselineRecord }
  256.                                                                 {     Default value:    All zeros.  Calculated from other style attributes (e.g., font and point size) }
  257.                                                                 {     Type:            UInt32 }
  258.     kATSULineLayoutOptionsTag    = 7;                            {     Default value:    kATSUNoLayoutOptions - other options listed in ATSLayoutTypes.h }
  259.  
  260. {    Run Style Attribute Tags }
  261.                                                                 {  QuickDraw compatibility tags  }
  262.     kATSUQDBoldfaceTag            = 256;                            {     Type:            Boolean     }
  263.                                                                 {     Default value:    false }
  264.     kATSUQDItalicTag            = 257;                            {     Type:            Boolean         }
  265.                                                                 {     Default value:    false }
  266.     kATSUQDUnderlineTag            = 258;                            {     Type:            Boolean     }
  267.                                                                 {     Default value:    false }
  268.     kATSUQDCondensedTag            = 259;                            {     Type:            Boolean     }
  269.                                                                 {     Default value:    false }
  270.     kATSUQDExtendedTag            = 260;                            {     Type:            Boolean     }
  271.                                                                 {     Default value:    false }
  272.                                                                 {  Common run tags  }
  273.     kATSUFontTag                = 261;                            {     Type:            ATSUFontID     }
  274.                                                                 {     Default value:    GetScriptVariable( smSystemScript, smScriptAppFond ) }
  275.     kATSUSizeTag                = 262;                            {     Type:            Fixed     }
  276.                                                                 {     Default value:    GetScriptVariable( smSystemScript, smScriptAppFondSize )     }
  277.     kATSUColorTag                = 263;                            {     Type:            RGBColor     }
  278.                                                                 {     Default value:    (0, 0, 0) }
  279.     kATSULanguageTag            = 264;                            {     Type:            RegionCode     }
  280.                                                                 {     Default value:    GetScriptVariable( smSystemScript, smScriptLang ) }
  281.                                                                 {     Less common run tags  }
  282.     kATSUVerticalCharacterTag    = 265;                            {     Type:            ATSUVerticalCharacterType     }
  283.                                                                 {     Default value:    kATSUStronglyHorizontal }
  284.     kATSUImposeWidthTag            = 266;                            {     Type:            ATSUTextMeasurement }
  285.                                                                 {     Default value:    0 }
  286.     kATSUBeforeWithStreamShiftTag = 267;                        {     Type:            Fixed }
  287.                                                                 {     Default value:    0 }
  288.     kATSUAfterWithStreamShiftTag = 268;                            {     Type:            Fixed }
  289.                                                                 {     Default value:    0 }
  290.     kATSUCrossStreamShiftTag    = 269;                            {     Type:            Fixed }
  291.                                                                 {     Default value:    0 }
  292.     kATSUTrackingTag            = 270;                            {     Type:            Fixed }
  293.                                                                 {     Default value:    0 }
  294.     kATSUHangingInhibitFactorTag = 271;                            {     Type:            Fract between 0 and 1 }
  295.                                                                 {     Default value:    0 }
  296.     kATSUKerningInhibitFactorTag = 272;                            {     Type:            Fract between 0 and 1 }
  297.                                                                 {     Default value:    0 }
  298.     kATSUDecompositionFactorTag    = 273;                            {     Type:            Fixed (-1.0 -> 1.0) }
  299.                                                                 {     Default value:    0 }
  300.     kATSUBaselineClassTag        = 274;                            {     Type:            BslnBaselineClass  (see SFNTLayoutTypes.h) }
  301.                                                                 {     Default value:    kBSLNNoBaselineOverride }
  302.     kATSUPriorityJustOverrideTag = 275;                            {     Type:            ATSJustPriorityWidthDeltaOverrides (see ATSLayoutTypes.h) }
  303.                                                                 {     Default value:    all zeros }
  304.     kATSUNoLigatureSplitTag        = 276;                            {     Type:            Boolean }
  305.                                                                 {     Default value:    false - ligatures and compound characters have divisable components. }
  306.     kATSUNoCaretAngleTag        = 277;                            {     Type:            Boolean }
  307.                                                                 {     Default value:    false - use the character's angularity to determine its boundaries }
  308.     kATSUSuppressCrossKerningTag = 278;                            {     Type:            Boolean }
  309.                                                                 {     Default value:    false - do not suppress automatic cross kerning (defined by font) }
  310.     kATSUNoOpticalAlignmentTag    = 279;                            {     Type:            Boolean }
  311.                                                                 {     Default value:    false - do not suppress character's automatic optical positional alignment }
  312.     kATSUForceHangingTag        = 280;                            {     Type:            Boolean }
  313.                                                                 {     Default value:    false - do not force the character's to hang beyond the line boundaries }
  314.     kATSUNoSpecialJustificationTag = 281;                        {     Type:            Boolean }
  315.                                                                 {     Default value:    false - perform post-compensation justification if needed }
  316.     kATSUMaxATSUITagValue        = 65535;                        {     This is the maximum Apple ATSUI reserved tag value.  Client defined tags must be larger. }
  317.  
  318. {******************************}
  319. {    Enumerations and constants    }
  320. {******************************}
  321. { Cursor movement }
  322.     kATSUByCharacter            = 0;
  323.     kATSUByCluster                = 1;
  324.     kATSUByWord                    = 2;
  325.  
  326. { Vertical text types }
  327.     kATSUStronglyHorizontal        = 0;
  328.     kATSUStronglyVertical        = 1;
  329.  
  330. { Line direction types (used for kATSULineDirectionTag values) }
  331.     kATSULeftToRightBaseDirection = 0;                            {     Impose left-to-right or top-to-bottom dominant direction  }
  332.     kATSURightToLeftBaseDirection = 1;                            {     Impose right-to-left or bottom-to-top dominant direction  }
  333.  
  334. { Style comparison types }
  335.     kATSUStyleUnequal            = 0;
  336.     kATSUStyleContains            = 1;
  337.     kATSUStyleEquals            = 2;
  338.     kATSUStyleContainedBy        = 3;
  339.  
  340. { LineFlushFactor convenience defined values }
  341.     kATSUStartAlignment            = $00000000;
  342.     kATSUEndAlignment            = $40000000;
  343.     kATSUCenterAlignment        = $20000000;
  344.  
  345. { LineJustificationFactor convenience defined values }
  346.     kATSUNoJustification        = $00000000;
  347.     kATSUFullJustification        = $40000000;
  348.  
  349. { Other constants    }
  350.     kATSUInvalidFontID            = 0;
  351.  
  352.  
  353.     kATSUUseLineControlWidth    = $7FFFFFFF;
  354.  
  355.  
  356.     kATSUUseGrafPortPenLoc        = $FFFFFFFF;
  357.     kATSUClearAll                = $FFFFFFFF;
  358.  
  359.  
  360.     kATSUFromTextBeginning        = $FFFFFFFF;
  361.     kATSUToTextEnd                = $FFFFFFFF;
  362.  
  363.  
  364. {**************}
  365. {    Functions    }
  366. {**************}
  367.  
  368. {    Basic style functions    }
  369. FUNCTION ATSUCreateStyle(VAR oStyle: ATSUStyle): OSStatus; C;
  370. FUNCTION ATSUCreateAndCopyStyle(iStyle: ATSUStyle; VAR oStyle: ATSUStyle): OSStatus; C;
  371. FUNCTION ATSUDisposeStyle(iStyle: ATSUStyle): OSStatus; C;
  372. FUNCTION ATSUSetStyleRefCon(iStyle: ATSUStyle; iRefCon: UInt32): OSStatus; C;
  373. FUNCTION ATSUGetStyleRefCon(iStyle: ATSUStyle; VAR oRefCon: UInt32): OSStatus; C;
  374.  
  375. {    Style comparison         }
  376. FUNCTION ATSUCompareStyles(iFirstStyle: ATSUStyle; iSecondStyle: ATSUStyle; VAR oComparison: ATSUStyleComparison): OSStatus; C;
  377. {    Attribute manipulations    }
  378. FUNCTION ATSUCopyAttributes(iSourceStyle: ATSUStyle; iDestinationStyle: ATSUStyle): OSStatus; C;
  379. FUNCTION ATSUOverwriteAttributes(iSourceStyle: ATSUStyle; iDestinationStyle: ATSUStyle): OSStatus; C;
  380. FUNCTION ATSUUnderwriteAttributes(iSourceStyle: ATSUStyle; iDestinationStyle: ATSUStyle): OSStatus; C;
  381. {    Empty styles    }
  382. FUNCTION ATSUClearStyle(iStyle: ATSUStyle): OSStatus; C;
  383. FUNCTION ATSUStyleIsEmpty(iStyle: ATSUStyle; VAR isClear: BOOLEAN): OSStatus; C;
  384. {    Clipboard support    }
  385. FUNCTION ATSUCopyToHandle(iStyle: ATSUStyle; oStyleHandle: Handle): OSStatus; C;
  386. FUNCTION ATSUPasteFromHandle(iStyle: ATSUStyle; iStyleHandle: Handle): OSStatus; C;
  387. {    Get and set attributes }
  388. FUNCTION ATSUCalculateBaselineDeltas(iStyle: ATSUStyle; iBaselineClass: BslnBaselineClass; VAR oBaselineDeltas: BslnBaselineRecord): OSStatus; C;
  389. FUNCTION ATSUSetAttributes(iStyle: ATSUStyle; iAttributeCount: ItemCount; VAR iTag: ATSUAttributeTag; VAR iValueSize: ByteCount; VAR iValue: ATSUAttributeValuePtr): OSStatus; C;
  390. FUNCTION ATSUGetAttribute(iStyle: ATSUStyle; iTag: ATSUAttributeTag; iExpectedValueSize: ByteCount; oValue: ATSUAttributeValuePtr; VAR oActualValueSize: ByteCount): OSStatus; C;
  391. FUNCTION ATSUGetAllAttributes(iStyle: ATSUStyle; VAR oAttributeInfoArray: ATSUAttributeInfo; iTagValuePairArraySize: ItemCount; VAR oTagValuePairCount: ItemCount): OSStatus; C;
  392. FUNCTION ATSUClearAttributes(iStyle: ATSUStyle; iTagCount: ItemCount; VAR iTag: ATSUAttributeTag): OSStatus; C;
  393. {    Font features    }
  394. FUNCTION ATSUSetFontFeatures(iStyle: ATSUStyle; iFeatureCount: ItemCount; VAR iType: ATSUFontFeatureType; VAR iSelector: ATSUFontFeatureSelector): OSStatus; C;
  395. FUNCTION ATSUGetFontFeature(iStyle: ATSUStyle; iFeatureIndex: ItemCount; VAR oFeatureType: ATSUFontFeatureType; VAR oFeatureSelector: ATSUFontFeatureSelector): OSStatus; C;
  396. FUNCTION ATSUGetAllFontFeatures(iStyle: ATSUStyle; iMaximumFeatureCount: ItemCount; VAR oFeatureType: ATSUFontFeatureType; VAR oFeatureSelector: ATSUFontFeatureSelector; VAR oActualFeatureCount: ItemCount): OSStatus; C;
  397. FUNCTION ATSUClearFontFeatures(iStyle: ATSUStyle; iFeatureCount: ItemCount; VAR iType: ATSUFontFeatureType; VAR iSelector: ATSUFontFeatureSelector): OSStatus; C;
  398. {    Font variations    }
  399. FUNCTION ATSUSetVariations(iStyle: ATSUStyle; iVariationCount: ItemCount; VAR iAxis: ATSUFontVariationAxis; VAR iValue: ATSUFontVariationValue): OSStatus; C;
  400. FUNCTION ATSUGetFontVariationValue(iStyle: ATSUStyle; iATSUFontVariationAxis: ATSUFontVariationAxis; VAR oATSUFontVariationValue: ATSUFontVariationValue): OSStatus; C;
  401. FUNCTION ATSUGetAllFontVariations(iStyle: ATSUStyle; iVariationCount: ItemCount; VAR oVariationAxes: ATSUFontVariationAxis; VAR oATSUFontVariationValues: ATSUFontVariationValue; VAR oActualVariationCount: ItemCount): OSStatus; C;
  402. FUNCTION ATSUClearFontVariations(iStyle: ATSUStyle; iAxisCount: ItemCount; VAR iAxis: ATSUFontVariationAxis): OSStatus; C;
  403. {    Basic text-layout functions    }
  404. FUNCTION ATSUCreateTextLayout(VAR oTextLayout: ATSUTextLayout): OSStatus; C;
  405. FUNCTION ATSUCreateTextLayoutWithTextPtr(iText: ConstUniCharArrayPtr; iTextOffset: UniCharArrayOffset; iTextLength: UniCharCount; iTextTotalLength: UniCharCount; iNumberOfRuns: ItemCount; VAR iRunLengths: UniCharCount; VAR iStyles: ATSUStyle; VAR oTextLayout: ATSUTextLayout): OSStatus; C;
  406. FUNCTION ATSUCreateTextLayoutWithTextHandle(iText: UniCharArrayHandle; iTextOffset: UniCharArrayOffset; iTextLength: UniCharCount; iTextTotalLength: UniCharCount; iNumberOfRuns: ItemCount; VAR iRunLengths: UniCharCount; VAR iStyles: ATSUStyle; VAR oTextLayout: ATSUTextLayout): OSStatus; C;
  407. FUNCTION ATSUDisposeTextLayout(iTextLayout: ATSUTextLayout): OSStatus; C;
  408. FUNCTION ATSUSetTextLayoutRefCon(iTextLayout: ATSUTextLayout; iRefCon: UInt32): OSStatus; C;
  409. FUNCTION ATSUGetTextLayoutRefCon(iTextLayout: ATSUTextLayout; VAR oRefCon: UInt32): OSStatus; C;
  410. {    Text location    }
  411. FUNCTION ATSUSetTextPointerLocation(iTextLayout: ATSUTextLayout; iText: ConstUniCharArrayPtr; iTextOffset: UniCharArrayOffset; iTextLength: UniCharCount; iTextTotalLength: UniCharCount): OSStatus; C;
  412. FUNCTION ATSUSetTextHandleLocation(iTextLayout: ATSUTextLayout; iText: UniCharArrayHandle; iTextOffset: UniCharArrayOffset; iTextLength: UniCharCount; iTextTotalLength: UniCharCount): OSStatus; C;
  413. FUNCTION ATSUGetTextLocation(iTextLayout: ATSUTextLayout; VAR oText: UNIV Ptr; VAR oTextIsStoredInHandle: BOOLEAN; VAR oOffset: UniCharArrayOffset; VAR oTextLength: UniCharCount; VAR oTextTotalLength: UniCharCount): OSStatus; C;
  414. {    Text manipulation    }
  415. FUNCTION ATSUTextDeleted(iTextLayout: ATSUTextLayout; iDeletedRangeStart: UniCharArrayOffset; iDeletedRangeLength: UniCharCount): OSStatus; C;
  416. FUNCTION ATSUTextInserted(iTextLayout: ATSUTextLayout; iInsertionLocation: UniCharArrayOffset; iInsertionLength: UniCharCount): OSStatus; C;
  417. FUNCTION ATSUTextMoved(iTextLayout: ATSUTextLayout; iNewLocation: ConstUniCharArrayPtr): OSStatus; C;
  418. {    Layout controls    }
  419. FUNCTION ATSUCopyLayoutControls(iSource: ATSUTextLayout; iDest: ATSUTextLayout): OSStatus; C;
  420. FUNCTION ATSUSetLayoutControls(iLayout: ATSUTextLayout; iAttributeCount: ItemCount; VAR iTag: ATSUAttributeTag; VAR iValueSize: ByteCount; VAR iValue: ATSUAttributeValuePtr): OSStatus; C;
  421. FUNCTION ATSUGetLayoutControl(iLayout: ATSUTextLayout; iTag: ATSUAttributeTag; iExpectedValueSize: ByteCount; oValue: ATSUAttributeValuePtr; VAR oActualValueSize: ByteCount): OSStatus; C;
  422. FUNCTION ATSUGetAllLayoutControls(iLayout: ATSUTextLayout; VAR oAttributeInfoArray: ATSUAttributeInfo; iTagValuePairArraySize: ItemCount; VAR oTagValuePairCount: ItemCount): OSStatus; C;
  423. FUNCTION ATSUClearLayoutControls(iLayout: ATSUTextLayout; iTagCount: ItemCount; VAR iTag: ATSUAttributeTag): OSStatus; C;
  424.  
  425.  
  426. {    Style run processing    }
  427. FUNCTION ATSUSetRunStyle(iTextLayout: ATSUTextLayout; iStyle: ATSUStyle; iRunStart: UniCharArrayOffset; iRunLength: UniCharCount): OSStatus; C;
  428. FUNCTION ATSUGetRunStyle(iTextLayout: ATSUTextLayout; iOffset: UniCharArrayOffset; VAR oStyle: ATSUStyle; VAR oRunStart: UniCharArrayOffset; VAR oRunLength: UniCharCount): OSStatus; C;
  429. FUNCTION ATSUGetContinuousAttributes(iTextLayout: ATSUTextLayout; iOffset: UniCharArrayOffset; iLength: UniCharCount; oStyle: ATSUStyle): OSStatus; C;
  430. {    Drawing and measuring    }
  431. FUNCTION ATSUDrawText(iTextLayout: ATSUTextLayout; iLineOffset: UniCharArrayOffset; iLineLength: UniCharCount; iLocationX: ATSUTextMeasurement; iLocationY: ATSUTextMeasurement): OSStatus; C;
  432. FUNCTION ATSUMeasureText(iTextLayout: ATSUTextLayout; iLineStart: UniCharArrayOffset; iLineLength: UniCharCount; VAR oTextBefore: ATSUTextMeasurement; VAR oTextAfter: ATSUTextMeasurement; VAR oAscent: ATSUTextMeasurement; VAR oDescent: ATSUTextMeasurement): OSStatus; C;
  433. FUNCTION ATSUMeasureTextImage(iTextLayout: ATSUTextLayout; iLineOffset: UniCharArrayOffset; iLineLength: UniCharCount; iLocationX: ATSUTextMeasurement; iLocationY: ATSUTextMeasurement; VAR oTextImageRect: Rect): OSStatus; C;
  434. {    Highlighting    }
  435. FUNCTION ATSUHighlightText(iTextLayout: ATSUTextLayout; iTextBasePointX: ATSUTextMeasurement; iTextBasePointY: ATSUTextMeasurement; iHighlightStart: UniCharArrayOffset; iHighlightLength: UniCharCount): OSStatus; C;
  436. FUNCTION ATSUUnhighlightText(iTextLayout: ATSUTextLayout; iTextBasePointX: ATSUTextMeasurement; iTextBasePointY: ATSUTextMeasurement; iHighlightStart: UniCharArrayOffset; iHighlightLength: UniCharCount): OSStatus; C;
  437. FUNCTION ATSUGetTextHighlight(iTextLayout: ATSUTextLayout; iTextBasePointX: ATSUTextMeasurement; iTextBasePointY: ATSUTextMeasurement; iHighlightStart: UniCharArrayOffset; iHighlightLength: UniCharCount; oHighlightRegion: RgnHandle): OSStatus; C;
  438. {    Hit-testing    }
  439. FUNCTION ATSUPositionToOffset(iTextLayout: ATSUTextLayout; iLocationX: ATSUTextMeasurement; iLocationY: ATSUTextMeasurement; VAR ioPrimaryOffset: UniCharArrayOffset; VAR oIsLeading: BOOLEAN; VAR oSecondaryOffset: UniCharArrayOffset): OSStatus; C;
  440. FUNCTION ATSUOffsetToPosition(iTextLayout: ATSUTextLayout; iOffset: UniCharArrayOffset; iIsLeading: BOOLEAN; VAR oMainCaret: ATSUCaret; VAR oSecondCaret: ATSUCaret; VAR oCaretIsSplit: BOOLEAN): OSStatus; C;
  441. {    Cursor movement    }
  442. FUNCTION ATSUNextCursorPosition(iTextLayout: ATSUTextLayout; iOldOffset: UniCharArrayOffset; iMovementType: ATSUCursorMovementType; VAR oNewOffset: UniCharArrayOffset): OSStatus; C;
  443. FUNCTION ATSUPreviousCursorPosition(iTextLayout: ATSUTextLayout; iOldOffset: UniCharArrayOffset; iMovementType: ATSUCursorMovementType; VAR oNewOffset: UniCharArrayOffset): OSStatus; C;
  444. FUNCTION ATSURightwardCursorPosition(iTextLayout: ATSUTextLayout; iOldOffset: UniCharArrayOffset; iMovementType: ATSUCursorMovementType; VAR oNewOffset: UniCharArrayOffset): OSStatus; C;
  445. FUNCTION ATSULeftwardCursorPosition(iTextLayout: ATSUTextLayout; iOldOffset: UniCharArrayOffset; iMovementType: ATSUCursorMovementType; VAR oNewOffset: UniCharArrayOffset): OSStatus; C;
  446. {    Line breaking    }
  447. FUNCTION ATSUBreakLine(iTextLayout: ATSUTextLayout; iLineStart: UniCharArrayOffset; iLineWidth: ATSUTextMeasurement; iUseAsSoftLineBreak: BOOLEAN; VAR oLineBreak: UniCharArrayOffset): OSStatus; C;
  448. FUNCTION ATSUSetSoftLineBreak(iTextLayout: ATSUTextLayout; iLineBreak: UniCharArrayOffset): OSStatus; C;
  449. FUNCTION ATSUGetSoftLineBreaks(iTextLayout: ATSUTextLayout; iRangeStart: UniCharArrayOffset; iRangeLength: UniCharCount; iMaximumBreaks: ItemCount; VAR oBreaks: UniCharArrayOffset; VAR oBreakCount: ItemCount): OSStatus; C;
  450. FUNCTION ATSUClearSoftLineBreaks(iTextLayout: ATSUTextLayout; iRangeStart: UniCharArrayOffset; iRangeLength: UniCharCount): OSStatus; C;
  451. {    Idle processing    }
  452. FUNCTION ATSUIdle(iTextLayout: ATSUTextLayout): OSStatus; C;
  453. {    Font matching    }
  454. FUNCTION ATSUMatchFontsToText(iTextLayout: ATSUTextLayout; iTextStart: UniCharArrayOffset; iTextLength: UniCharCount; VAR oFont: ATSUFontID; VAR oChangedOffset: UniCharArrayOffset; VAR oChangedLength: UniCharCount): OSStatus; C;
  455. FUNCTION ATSUSetTransientFontMatching(iTextLayout: ATSUTextLayout; iTransientFontMatching: BOOLEAN): OSStatus; C;
  456. FUNCTION ATSUGetTransientFontMatching(iTextLayout: ATSUTextLayout; VAR oTransientFontMatching: BOOLEAN): OSStatus; C;
  457. {    Font ID's    }
  458. FUNCTION ATSUFontCount(VAR oFontCount: ItemCount): OSStatus; C;
  459. FUNCTION ATSUGetFontIDs(VAR oFontIDs: ATSUFontID; iArraySize: ItemCount; VAR oFontCount: ItemCount): OSStatus; C;
  460. FUNCTION ATSUFONDtoFontID(iFONDNumber: INTEGER; iFONDStyle: ByteParameter; VAR oFontID: ATSUFontID): OSStatus; C;
  461. FUNCTION ATSUFontIDtoFOND(iFontID: ATSUFontID; VAR oFONDNumber: INTEGER; VAR oFONDStyle: Style): OSStatus; C;
  462. {    Font names    }
  463. FUNCTION ATSUCountFontNames(iFontID: ATSUFontID; VAR oFontNameCount: ItemCount): OSStatus; C;
  464. FUNCTION ATSUGetIndFontName(iFontID: ATSUFontID; iFontNameIndex: ItemCount; iMaximumNameLength: ByteCount; oName: Ptr; VAR oActualNameLength: ByteCount; VAR oFontNameCode: FontNameCode; VAR oFontNamePlatform: FontPlatformCode; VAR oFontNameScript: FontScriptCode; VAR oFontNameLenguage: FontLanguageCode): OSStatus; C;
  465. FUNCTION ATSUFindFontName(iFontID: ATSUFontID; iFontNameCode: FontNameCode; iFontNamePlatform: FontPlatformCode; iFontNameScript: FontScriptCode; iFontNameLanguage: FontLanguageCode; iMaximumNameLength: ByteCount; oName: Ptr; VAR oActualNameLength: ByteCount; VAR oFontNameIndex: ItemCount): OSStatus; C;
  466. FUNCTION ATSUFindFontFromName(iName: Ptr; iNameLength: ByteCount; iFontNameCode: FontNameCode; iFontNamePlatform: FontPlatformCode; iFontNameScript: FontScriptCode; iFontNameLanguage: FontLanguageCode; VAR oFontID: ATSUFontID): OSStatus; C;
  467. {    Font features    }
  468. FUNCTION ATSUCountFontFeatureTypes(iFont: ATSUFontID; VAR oTypeCount: ItemCount): OSStatus; C;
  469. FUNCTION ATSUCountFontFeatureSelectors(iFont: ATSUFontID; iType: ATSUFontFeatureType; VAR oSelectorCount: ItemCount): OSStatus; C;
  470. FUNCTION ATSUGetFontFeatureTypes(iFont: ATSUFontID; iMaximumTypes: ItemCount; VAR oTypes: ATSUFontFeatureType; VAR oActualTypeCount: ItemCount): OSStatus; C;
  471. FUNCTION ATSUGetFontFeatureSelectors(iFont: ATSUFontID; iType: ATSUFontFeatureType; iMaximumSelectors: ItemCount; VAR oSelectors: ATSUFontFeatureSelector; VAR oSelectorIsOnByDefault: BOOLEAN; VAR oActualSelectorCount: ItemCount; VAR oIsMutuallyExclusive: BOOLEAN): OSStatus; C;
  472. FUNCTION ATSUGetFontFeatureNameCode(iFont: ATSUFontID; iType: ATSUFontFeatureType; iSelector: ATSUFontFeatureSelector; VAR oNameCode: FontNameCode): OSStatus; C;
  473. {    Font variations    }
  474. FUNCTION ATSUCountFontVariations(iFont: ATSUFontID; VAR oVariationCount: ItemCount): OSStatus; C;
  475. FUNCTION ATSUGetIndFontVariation(iFont: ATSUFontID; iVariationIndex: ItemCount; VAR oATSUFontVariationAxis: ATSUFontVariationAxis; VAR oMinimumValue: ATSUFontVariationValue; VAR oMaximumValue: ATSUFontVariationValue; VAR oDefaultValue: ATSUFontVariationValue): OSStatus; C;
  476. FUNCTION ATSUGetFontVariationNameCode(iFont: ATSUFontID; iAxis: ATSUFontVariationAxis; VAR oNameCode: FontNameCode): OSStatus; C;
  477.  
  478. {    Font Instances    }
  479. FUNCTION ATSUCountFontInstances(iFont: ATSUFontID; VAR oInstances: ItemCount): OSStatus; C;
  480. FUNCTION ATSUGetFontInstance(iFont: ATSUFontID; iFontInstanceIndex: ItemCount; iMaximumVariations: ItemCount; VAR oAxes: ATSUFontVariationAxis; VAR oValues: ATSUFontVariationValue; VAR oActualVariationCount: ItemCount): OSStatus; C;
  481. FUNCTION ATSUGetFontInstanceNameCode(iFont: ATSUFontID; iInstanceIndex: ItemCount; VAR oNameCode: FontNameCode): OSStatus; C;
  482. {$ALIGN RESET}
  483. {$POP}
  484.  
  485. {$SETC UsingIncludes := ATSUnicodeIncludes}
  486.  
  487. {$ENDC} {__ATSUNICODE__}
  488.  
  489. {$IFC NOT UsingIncludes}
  490.  END.
  491. {$ENDC}
  492.